package cn.tworice.admin.service.impl;

import cn.tworice.admin.dao.RoleDao;
import cn.tworice.admin.service.RoleService;
import cn.tworice.auth.CacheConst;
import cn.tworice.common.entity.Admin;
import cn.tworice.common.entity.Role;
import cn.tworice.common.entity.RoleResources;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


/**
 * 角色管理服务
 */
@Service
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleDao roleDao;

    /**
     * 获取所有角色列表
     * @author 二饭
     */
    @Override
    public List<Role> getRoleList() {
        return roleDao.queryRoles();
    }

    /**
     * 根据角色ID获取人员列表
     * @author 二饭
     */
    @Override
    public List<Admin> getAdminListByRoleId(Integer roleId) {
        return roleDao.queryAdminByRoleId(roleId);
    }

    /**
     * 添加人员到角色
     * @author 二饭
     */
    @Override
    public int addAdminToRole(String[] adminId, Integer roleId) {
        CacheConst.clearRoles(adminId);
        CacheConst.clearResources(adminId);

        // 判断该角色中有没有该人员
        int i=roleDao.queryAdminInRole(adminId,roleId);
        if(i==0){
            // 如果没有
            return roleDao.insertAdminToRole(adminId, roleId);
        }
        return 0;
    }

    /**
     * 从角色中移除人员
     * @author 二饭
     */
    @Override
    public void delAdminToRole(String[] adminIds, Integer roleId) {
        CacheConst.clearRoles(adminIds);
        CacheConst.clearResources(adminIds);

        roleDao.rmAdminToRole(adminIds, roleId);
    }

    /**
     * 获取不是该角色的人员
     * @author 二饭
     */
    @Override
    public List<Admin> getNoRoleAdmin(int roleId) {
        return roleDao.queryNoRoleAdmin(roleId);
    }

    /**
     * 通过用户状态查询用户
     * @author 二饭
     */
    @Override
    public List<Admin> getAdminByStatus(Integer status) {
        return roleDao.queryAdminByStatus(status);
    }

    /**
     * 通过角色ID查询资源
     * @author 二饭
     */
    @Override
    public List<RoleResources> getResourcesByRoleId(Integer roleId) {
        return roleDao.queryResourcesByRoleId(roleId);
    }

    /**
     * 更新角色权限资源
     * @author 二饭
     */
    @Override
    public Boolean updateRoleResources(Integer[] haveResources, Integer[] updateResources, Integer roleId) {
        CacheConst.RESOURCES.clear();

        List<Integer> addResources = new ArrayList<>();
        List<Integer> rmResources = new ArrayList<>();
        // 计算增加的资源权限
        for(Integer i:updateResources){
            // 该ID原来未被选中
            if(!Arrays.asList(haveResources).contains(i)){
                addResources.add(i);
            }
        }
        // 计算删除的资源权限
        for(Integer i:haveResources){
            // 该ID现在被取消
            if(!Arrays.asList(updateResources).contains(i)){
                rmResources.add(i);
            }
        }

        if(addResources.size()!=0){
            roleDao.insertRoleResources(addResources,roleId);
        }
        if(rmResources.size()!=0){
            roleDao.rmRoleResources(rmResources, roleId);
        }

        return true;
    }

    /**
     * 删除角色
     * 需要同时删除 角色表 和 角色资源表 所有相关内容
     * @author 二饭
     */
    @Override
    public int delRole(Integer roleId) {
        CacheConst.ROLES.clear();
        CacheConst.RESOURCES.clear();

        int i=roleDao.delRole(roleId);

        // 同时删除角色相关的 人员角色、角色权限相关数据信息
        if(i==1){
            roleDao.delRoleResources(roleId);
            roleDao.delAdminRoleByRole(roleId);
        }
        return i;
    }

    /**
     * 更新或插入角色
     * @author 二饭
     */
    @Override
    public int editRole(Integer roleId, String roleName) {
        int i=0;
        if (roleId == -1) {
            // 插入
            i = roleDao.insertRole(roleName);
        } else {
            // 更新
            i = roleDao.updateRole(roleId, roleName);

        }
        return i;
    }

    /**
     * 更新角色的资源权限
     * @author 二饭
     */
    @Override
    public Boolean setRoleResources(Integer roleId, Integer[] resourcesId) {
        CacheConst.RESOURCES.clear();

        // 删除原有资源权限
        roleDao.delRoleResources(roleId);
        // 设置新的资源权限（资源的叶子节点）
        roleDao.insertRoleResource(roleId,resourcesId);
        return true;
    }

    /**
     * 通过人员id删除 人员角色关系信息
     * @param ids 人员ID
     * @author 二饭 [2022/5/20]
     **/
    @Override
    public int delAdminRoleByAdmin(String[] ids) {
        CacheConst.clearRoles(ids);
        CacheConst.clearResources(ids);

        return roleDao.delAdminRoleByAdmin(ids);
    }


}